package thread;

/**
 * 线程的内容
 * 参考:http://www.cnblogs.com/whoislcj/p/5603277.html
 */
public class Demo01Thread {
    public static void main(String[] args) {
        /**
         * Thread主要方法:
         *
         * start()   //执行线程
         * sleep()/sleep(long millis)    //线程休眠,让CPU去执行其他的任务，让线程进入阻塞状态，sleep方法不会释放锁
         * wait()                        //线程休眠,让CPU去执行其他的任务，让线程进入阻塞状态，同时也会释放锁
         * interrupt()   //中断线程，自stop函数过时之后，我们通过interrupt方法和isInterrupted()方法来停止正在运行的线程，注意只能中断已经处于阻塞的线程
         * yield()       //使当前线程交出CPU，让CPU去执行其他的任务，但不会是线程进入阻塞状态，而是重置为就绪状态，yield方法不会释放锁
         * join()/join(long millis)  //加入(插队)线程，就是发起的线程 其他线程只能等待该线程运行结束才能继续往下运行
         * isAlive()     //判断当前线程是否处于活动状态
         *
         * getId()                     //获取当前线程的ID
         * getName()/setName()         //获取和设置线程的名字
         * getPriority()/setPriority() //获取和这是线程的优先级 一般property用1-10的整数表示，默认优先级是5，优先级最高是10，优先级高的线程被执行的机率高
         * setDaemon()/isDaemo()       //设置和判断是否是守护线程
         * Thread.currentThread()      //静态函数获取当前线程
         */
        SyncRunnable syncRunnable = new SyncRunnable();

        Thread thread = new Thread(syncRunnable, "原生线程1");
        SyncThread syncThread1 = new SyncThread("自定义线程2");
        SyncThread syncThread2 = new SyncThread("自定义线程3");
        SyncThread syncThread3 = new SyncThread("自定义线程4");
        /**
         * Thread线程主要状态
         *
         * NEW     :(新建状态)一旦被实例就处于new状态
         * RUNNABLE:(运行状态)调用了start函数之后就处于Runnable状态
         * TIMED_WAITING :(计时等待状态) 调用sleep(long)、wait(long)、join()是线程计时等待状态
         * WAITING :(无限永久等待状态) 调用Object().wait()将处于植物人状态了,需要用Object().notify()唤醒
         * BLOCKED :(阻塞状态)使休眠结束,cpu不空闲处于Blocked状态
         * TERMINATED :(死亡状态)已退出的线程处于这样的状态
         */
        thread.start();
        syncThread1.start();
        syncThread2.start();
        syncThread3.start();

        //针对线程停止的玩法
//        Thread mThread = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                try {
//                    for (int i = 0; i < 500000; i++) {
//                        if (Thread.currentThread().isInterrupted()) {
//                            System.out.println("线程已经终止， for循环不再执行");
//                            throw new InterruptedException();
//                        }
//                        System.out.println("i:" + i);
//                    }
//                    System.out.println("还是会执行的,线程还是没有停止");
//                } catch (InterruptedException e) {
//                    System.out.println("应该是停止了!");
//                    e.printStackTrace();
//                }
//            }
//        });
//        mThread.start();
//        destroyThread(mThread);


        /**
         * java.util.concurrent.TimeUnit
         * TimeUnit vs Thread 更加优雅的使线程休眠
         */
//        TimeUnit.SECONDS.toMillis(1); //1秒转换为毫秒数
//        TimeUnit.SECONDS.toMinutes(60); //60秒转换为分钟数
//        TimeUnit.SECONDS.convert(1, TimeUnit.MINUTES); //1分钟转换为秒数
//        TimeUnit.MILLISECONDS.sleep(5); //线程休眠5毫秒
//        TimeUnit.DAYS 日的工具类
//        TimeUnit.HOURS 时的工具类
//        TimeUnit.MINUTES 分的工具类
//        TimeUnit.SECONDS 秒的工具类
//        TimeUnit.MILLISECONDS 毫秒的工具类
    }

    /**
     * 销毁线程方法(对应上边的方法才奏效)
     */
    private static void destroyThread(Thread thread) {
        if (null != thread && Thread.State.RUNNABLE == thread.getState()) {
            try {
                Thread.sleep(500);
                thread.interrupt();  //结束阻塞的线程;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 自定义Thread线程
 */
class SyncThread extends Thread {

    public SyncThread(String name) {
        super(name);
    }

    @Override
    public void run() { //执行耗时操作
        System.out.println("我是线程:" + Thread.currentThread().getName());
    }
}


/**
 * 实现Runnable方式.它不是线程,它只是任务
 */
class SyncRunnable implements Runnable {
    @Override
    public void run() {  //执行耗时操作
        System.out.println("我是线程" + Thread.currentThread().getName());
    }
}
